package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade MOTIVO_APROVA_REPROVA_ENSAIO
 * @author Gerado pelo Telescope
 */
public class EntMotivoAprovaReprovaEnsaio extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.MOTIVO_APROVA_REPROVA_ENSAIO";
    public final static String TABLE_NAME = "MOTIVO_APROVA_REPROVA_ENSAIO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntMotivoAprovaReprovaEnsaio() {
        super();
        initialize();
    }
    
    public EntMotivoAprovaReprovaEnsaio(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aMotivo = new DomUpper(this,"MOTIVO", "Motivo (aprovação/reprovação)"); 
        aMotivo.setRequired(true);
        aMotivo.setSize(32);
        oMotivo = new DomUpper();
        aDescricao = new DomTextLong(this,"DESCRICAO", "Descrição do motivo"); 
        aDescricao.setSize(256);
        oDescricao = new DomTextLong();
        aClassificacao = new DomOpcao(this,"CLASSIFICACAO", "Classificação"); 
        aClassificacao.setRequired(true);
        aClassificacao.setSize(1);
        aClassificacao.clearOptions();
        aClassificacao.addOption("R", "Motivo de reprovação");
        aClassificacao.addOption("A", "Motivo para aprovação");
        aClassificacao.setDefaultValue("R");
        oClassificacao = new DomOpcao();
        aExigeParecer = new DomFlag(this,"EXIGE_PARECER", "Exige parecer"); 
        aExigeParecer.setRequired(true);
        aExigeParecer.setDefaultValue("N");
        oExigeParecer = new DomFlag();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Motivo (aprovação/reprovação)
    private DomUpper aMotivo;
    private DomUpper oMotivo;
    
    // Descrição do motivo
    private DomTextLong aDescricao;
    private DomTextLong oDescricao;
    
    // Classificação
    private DomOpcao aClassificacao;
    private DomOpcao oClassificacao;
    
    // Exige parecer
    private DomFlag aExigeParecer;
    private DomFlag oExigeParecer;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntMotivoAprovaReprovaEnsaio id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MOTIVO">
    
    public EntMotivoAprovaReprovaEnsaio motivo(String value) {
        setMotivo(value);
        return this;
    }
    
    public void setMotivo(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyMotivo();
        } else {
            aMotivo.setValue(value.getValue());
            if (aMotivo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMotivo(String value) {
        if (value == null) {
            nullifyMotivo();
        } else {
            aMotivo.setValue(value);
            if (aMotivo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMotivo(Object value) {
        aMotivo.setValue(value);
        if (aMotivo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyMotivo() {
        if (!aMotivo.isNull()) {
            aMotivo.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getMotivo() {
        return aMotivo;
    }
    
    public DomUpper oldMotivo() {
        return oMotivo;
    }
    
    public String valueOfMotivo() {
        return aMotivo.getValue();
    }
    
    public boolean isMotivoModified() {
        return aMotivo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESCRICAO">
    
    public EntMotivoAprovaReprovaEnsaio descricao(String value) {
        setDescricao(value);
        return this;
    }
    
    public void setDescricao(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value.getValue());
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(String value) {
        if (value == null) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value);
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(Object value) {
        aDescricao.setValue(value);
        if (aDescricao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDescricao() {
        if (!aDescricao.isNull()) {
            aDescricao.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getDescricao() {
        return aDescricao;
    }
    
    public DomTextLong oldDescricao() {
        return oDescricao;
    }
    
    public String valueOfDescricao() {
        return aDescricao.getValue();
    }
    
    public boolean isDescricaoModified() {
        return aDescricao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CLASSIFICACAO">
    
    public EntMotivoAprovaReprovaEnsaio classificacao(String value) {
        setClassificacao(value);
        return this;
    }
    
    public void setClassificacao(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifyClassificacao();
        } else {
            aClassificacao.setValue(value.getValue());
            if (aClassificacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setClassificacao(String value) {
        if (value == null) {
            nullifyClassificacao();
        } else {
            aClassificacao.setValue(value);
            if (aClassificacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setClassificacao(Object value) {
        aClassificacao.setValue(value);
        if (aClassificacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyClassificacao() {
        if (!aClassificacao.isNull()) {
            aClassificacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getClassificacao() {
        return aClassificacao;
    }
    
    public DomOpcao oldClassificacao() {
        return oClassificacao;
    }
    
    public String valueOfClassificacao() {
        return aClassificacao.getValue();
    }
    
    public boolean isClassificacaoModified() {
        return aClassificacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo EXIGE_PARECER">
    
    public EntMotivoAprovaReprovaEnsaio exigeParecer(String value) {
        setExigeParecer(value);
        return this;
    }
    
    public void setExigeParecer(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyExigeParecer();
        } else {
            aExigeParecer.setValue(value.getValue());
            if (aExigeParecer.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setExigeParecer(String value) {
        if (value == null) {
            nullifyExigeParecer();
        } else {
            aExigeParecer.setValue(value);
            if (aExigeParecer.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setExigeParecer(Object value) {
        aExigeParecer.setValue(value);
        if (aExigeParecer.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyExigeParecer() {
        if (!aExigeParecer.isNull()) {
            aExigeParecer.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getExigeParecer() {
        return aExigeParecer;
    }
    
    public DomFlag oldExigeParecer() {
        return oExigeParecer;
    }
    
    public String valueOfExigeParecer() {
        return aExigeParecer.getValue();
    }
    
    public boolean isExigeParecerModified() {
        return aExigeParecer.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.HIDROMETRO_ENSAIO.FK_HROEN_MOTIVO_APROVAO_REPROVA
        {
            EntHidrometroEnsaio external = new EntHidrometroEnsaio(ctx);
            external.findByMotivoAprovaoReprova(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.HIDROMETRO_ENSAIO.FK_HROEN_MOTIVO_APROVAO_REPROVA.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Hidrômetros relacionados para os ensaios fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_HROEN_MOTIVO_APROVAO_REPROVA") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.FK_HROEN_MOTIVO_APROVAO_REPROVA.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Hidrômetros relacionados para os ensaios fazendo referencia para este registro! (FK_HROEN_MOTIVO_APROVAO_REPROVA)");
                return e;
            } else {
                e = new AdsException("ZTEST.MOTIVO_APROVA_REPROVA_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("PK_MAOURE") >= 0) {
                e = new AdsException("ZTEST.MOTIVO_APROVA_REPROVA_ENSAIO.PK_MAOURE", 
                        Severity.ERROR,
                        "ID duplicado! (PK_MAOURE)");
                return e;
            } else {
                e = new AdsException("ZTEST.MOTIVO_APROVA_REPROVA_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aMotivo);
            allAttributes.add(aDescricao);
            allAttributes.add(aClassificacao);
            allAttributes.add(aExigeParecer);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return "";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    /**
     * Retorna os registros de HIDROMETRO_ENSAIO que referenciam este registro através do atributo MOTIVO_APROVAO_REPROVA_ID
     */
    public EntHidrometroEnsaio findAllHidrometroEnsaioMotivoAprovaoReprova() throws AdsException {
        return findAllHidrometroEnsaioMotivoAprovaoReprova("order by ID");
    }
    
    /**
     * Retorna os registros de HIDROMETRO_ENSAIO que referenciam este registro através do atributo MOTIVO_APROVAO_REPROVA_ID
     */
    public EntHidrometroEnsaio findAllHidrometroEnsaioMotivoAprovaoReprova(String sqlAppend) throws AdsException {
        EntHidrometroEnsaio out = new EntHidrometroEnsaio(ctx);
        out.find("select ID from HIDROMETRO_ENSAIO where MOTIVO_APROVAO_REPROVA_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oExigeParecer.setValue(aExigeParecer);
        oClassificacao.setValue(aClassificacao);
        oDescricao.setValue(aDescricao);
        oMotivo.setValue(aMotivo);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntMotivoAprovaReprovaEnsaio.class);
            rule.setName("PK_MAOURE");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntMotivoAprovaReprovaEnsaio.class);
            rule.setCheckAttribute(new DomOpcao("CLASSIFICACAO",""));
            rule.setName("CKAV_22037435");
            rule.addAllowableValues(new String[] {"R", "A"});
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getExigeParecer().isNull()) {
            setExigeParecer(getExigeParecer().getDefaultValue());
        }
        if (getClassificacao().isNull()) {
            setClassificacao(getClassificacao().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
